import { ref, reactive, onMounted } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import { useCustomerStore } from '@/store/customer'
import { useUserStore } from '@/store/user'
import { customerApi } from '@/api/customer'
import { useRegionOptimized } from '@/hooks/useRegionOptimized'
import type {
  Customer,
  CustomerContact,
  CustomerTrace,
  CustomerChance,
  CustomerLog,
} from '@/types/customer'
import type { TableColumn } from '@/types/common'
import type { ApiResponse } from '@/types/api'

// 客户添加组件引用
const customerAddRef = ref<{ handleSubmit: () => void } | null>(null)

// 定义级联选择器选项类型
interface CascaderOption {
  value: number
  label: string
  children?: CascaderOption[]
}

// 列表Tab相关
const activeListTab = ref<string>('my')

// 查询表单
const queryForm = reactive({
  page: 1,
  limit: 10,
  keywords: '',
  type: '',
  admin_id: '',
  start_time: '',
  end_time: '',
  grade: '',
  grade_id: '',
  region: '', // 现在存储的是数组格式的级联选择值
  source_id: '',
  min_amount: undefined as number | undefined,
  max_amount: undefined as number | undefined,
})

// 高级搜索表单
const advancedForm = reactive({
  admin_id: null as string | null,
  createTimeRange: [],
  grade_id: '',
  region: [] as number[], // 修改为数组格式，存储级联选择的值
  source_id: '',
  min_amount: undefined as number | undefined,
  max_amount: undefined as number | undefined,
})

// 高级搜索显示控制
const isAdvancedSearch = ref<boolean>(false)

// 标记是否应用了高级搜索条件
const hasAppliedAdvancedSearch = ref<boolean>(false)

// 标记是否应该忽略高级搜索中的admin_id
const ignoreAdvancedSearchAdminId = ref<boolean>(false)

// 管理员选项
const adminOptions = ref<Array<{ id: number; name: string }>>([])

// 统一的管家数据加载函数 - 替换preloadAdminData和loadOptions中的重复逻辑
const loadAdminData = async (forceRefresh: boolean = false) => {
  console.log(`加载管家数据${forceRefresh ? '(强制刷新)' : ''}...`)
  try {
    // 定义缓存键名
    const CACHE_KEY = 'customer_admin_list_cache'
    // 管家列表缓存时间（1小时）
    const CACHE_EXPIRY = 60 * 60 * 1000

    // 如果不需要强制刷新，先尝试从缓存获取
    if (!forceRefresh) {
      const cached = localStorage.getItem(CACHE_KEY)
      if (cached) {
        const { data, timestamp } = JSON.parse(cached)
        // 检查是否过期或数据为空
        if (Date.now() - timestamp < CACHE_EXPIRY && Array.isArray(data) && data.length > 0) {
          console.log('使用缓存的管家列表数据')
          adminOptions.value = data
          console.log('加载缓存数据，管家数量:', adminOptions.value.length)
          return true
        } else {
          console.log(
            `管家列表缓存${Date.now() - timestamp >= CACHE_EXPIRY ? '已过期' : '数据为空'}，重新获取`
          )
        }
      }
    }

    // 缓存不存在/已过期/强制刷新，从服务器获取
    const adminRes: any = await customerApi.getAdminList()
    console.log('管家列表API响应:', adminRes)

    // 详细记录API响应结构，帮助调试
    console.log('API响应完整结构:', JSON.stringify(adminRes, null, 2))

    // 统一处理不同的响应格式
    let adminData = []
    if (adminRes && adminRes.code === 0) {
      console.log('API返回成功状态，code:', adminRes.code)

      // 处理直接返回数组的情况
      if (Array.isArray(adminRes.data)) {
        console.log('API返回数据直接是数组，长度:', adminRes.data.length)
        adminData = adminRes.data
      }
      // 处理返回带有list字段的情况
      else if (adminRes.data && Array.isArray(adminRes.data.list)) {
        console.log('API返回数据包含list字段，列表长度:', adminRes.data.list.length)
        adminData = adminRes.data.list
      }
      // 新增：处理可能的其他数据结构
      else if (adminRes.data && typeof adminRes.data === 'object') {
        console.log('API返回数据是对象，但不包含预期的数组结构，检查是否有其他列表字段')
        console.log('数据对象的所有键:', Object.keys(adminRes.data))

        // 尝试查找可能的其他列表字段
        const listFields = Object.keys(adminRes.data).filter(key =>
          Array.isArray(adminRes.data[key])
        )
        console.log('数据对象中找到的数组字段:', listFields)

        // 如果有数组字段，使用第一个作为数据来源
        if (listFields.length > 0) {
          console.log(
            `使用数组字段 ${listFields[0]} 作为数据来源，长度:`,
            adminRes.data[listFields[0]].length
          )
          adminData = adminRes.data[listFields[0]]
        }
      }

      console.log('最终解析的数据长度:', adminData.length)
    }

    // 如果有数据，处理并更新
    if (adminData.length > 0) {
      // 更新管家列表，增强数据映射逻辑
      adminOptions.value = adminData.map((item: any) => ({
        id: item.id,
        name: item.name || item.username || item.nickname || `管家${item.id}`,
      }))

      // 更新缓存
      try {
        const cacheData = {
          data: adminOptions.value,
          timestamp: Date.now(),
        }
        localStorage.setItem(CACHE_KEY, JSON.stringify(cacheData))
        console.log('管家列表数据已更新缓存')
      } catch (e) {
        console.error('更新管家列表缓存失败:', e)
      }

      console.log('管家列表加载成功，数量:', adminOptions.value.length)
      return true
    } else {
      // 区分API调用成功但返回空数据的情况
      if (adminRes && adminRes.code === 0) {
        console.log('API调用成功，但返回空数据，消息:', adminRes?.msg || '无消息')
      } else {
        console.error('获取管家列表失败:', adminRes?.msg || 'API返回空数据')
      }
      // 如果加载失败且当前没有数据，则使用静态数据
      if (adminOptions.value.length === 0) {
        console.log('当前无管家数据，使用静态数据作为备用')
        adminOptions.value = [
          { id: 1, name: '管理员' },
          { id: 2, name: '销售经理' },
          { id: 3, name: '客户经理' },
          { id: 4, name: '项目经理' },
          { id: 5, name: '财务经理' },
        ]
      }
      return false
    }
  } catch (error) {
    console.error('加载管家列表时发生异常:', error)
    // 如果加载失败且当前没有数据，则使用静态数据
    if (adminOptions.value.length === 0) {
      console.log('发生异常，使用静态数据作为备用')
      adminOptions.value = [
        { id: 1, name: '管理员' },
        { id: 2, name: '销售经理' },
        { id: 3, name: '客户经理' },
        { id: 4, name: '项目经理' },
        { id: 5, name: '财务经理' },
      ]
    }
    return false
  }
}

// 客户等级选项
const gradeOptions = ref<Array<{ id: number | string; name: string }>>([])

// 客户状态选项
const customerStatusOptions = ref<Array<{ id: number | string; name: string }>>([])

// 客户来源选项
const sourceOptions = ref<Array<{ id: number | string; name: string }>>([])

// 级联选择器的地区选项数据
const cascaderRegionOptions = ref<CascaderOption[]>([])

// 选中的地区数据
const regionData = ref<any>({
  provinceid: '',
  cityid: '',
  distid: '',
})

// 级联选择器的配置 - 修改为允许只选择一级就确定
const cascaderProps = {
  value: 'value',
  label: 'label',
  children: 'children',
  expandTrigger: 'hover' as const,
  multiple: false,
  checkStrictly: true, // 允许只选择一级就确定
  emitPath: false, // 只返回选中节点的值，而不是完整路径
}

// 选中的客户
const selectedCustomers = ref<any[]>([])

// 数据相关
const customerList = ref<any[]>([])
const total = ref<number>(0)
const loading = ref<boolean>(false)

// 格式化金额
const formatAmount = (amount: number | string | undefined) => {
  if (amount === undefined || amount === null) return '¥0.00'
  const num = parseFloat(String(amount))
  if (isNaN(num)) return '¥0.00'
  // 使用千分位表示法
  return `¥${num.toLocaleString('zh-CN', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
}

// 搜索
const handleSearch = () => {
  queryForm.page = 1
  loadCustomerList()
}

// 重置
const handleReset = () => {
  queryForm.keywords = ''
  queryForm.type = ''
  queryForm.grade_id = ''
  queryForm.region = ''
  queryForm.source_id = ''
  queryForm.min_amount = undefined
  queryForm.max_amount = undefined
  queryForm.start_time = ''
  queryForm.end_time = ''
  queryForm.page = 1

  // 根据当前标签决定是否设置admin_id
  const userStore = useUserStore()
  const currentUserId = userStore.userInfo?.id ? String(userStore.userInfo.id) : ''

  if (activeListTab.value === 'my') {
    queryForm.admin_id = currentUserId
  } else {
    queryForm.admin_id = ''
  }

  loadCustomerList()
}

// Customer store
const customerStore = useCustomerStore()

// 对话框相关
const detailDialogVisible = ref<boolean>(false)
const currentCustomer = ref<any>(null)
const activeTab = ref<string>('contact')

// 客户详情抽屉
const detailDrawerVisible = ref<boolean>(false)
const currentDetailCustomerId = ref<string | number>('')

// 编辑客户抽屉
const editDrawerVisible = ref<boolean>(false)
const currentEditCustomerId = ref<string | number>('')

// 子表数据
const contactList = ref<any[]>([])
const traceList = ref<any[]>([])
const chanceList = ref<any[]>([])
const logList = ref<any[]>([])

// 抽屉表单相关
const drawerVisible = ref<boolean>(false)
const submitting = ref<boolean>(false)

// 关闭抽屉
const closeDrawer = () => {
  drawerVisible.value = false
  return true
}

// 关闭详情抽屉
const closeDetailDrawer = () => {
  // 关闭抽屉
  detailDrawerVisible.value = false
  // 延迟清空ID，确保抽屉关闭动画完成后再清空
  setTimeout(() => {
    // 重置当前客户ID，避免缓存问题
    currentDetailCustomerId.value = ''
  }, 300)
  return true
}

// 关闭编辑抽屉
const closeEditDrawer = () => {
  editDrawerVisible.value = false
  return true
}

// 处理新增客户提交事件
const handleAddSubmit = (formData: any) => {
  console.log('新增客户提交:', formData)
  closeDrawer()
  // 刷新列表
  loadCustomerList()
}

// 提交表单
const submitForm = async () => {
  // 这里将在抽屉中加载的组件处理提交逻辑
  ElMessage.info('在抽屉组件中处理提交逻辑')
  closeDrawer()
  // 刷新列表
  loadCustomerList()
}

// 处理编辑客户提交事件
const handleEditSubmit = (formData: any) => {
  console.log('编辑客户提交:', formData)
  closeEditDrawer()
  // 刷新列表
  loadCustomerList()
}

// 提交编辑表单
const submitEditForm = async () => {
  // 这里将在抽屉中加载的组件处理提交逻辑
  ElMessage.info('在抽屉组件中处理提交逻辑')
  closeEditDrawer()
  // 刷新列表
  loadCustomerList()
}

// 处理Tab切换
const handleTabChange = () => {
  // 使用用户存储获取当前用户信息，而不是直接从localStorage获取
  const userStore = useUserStore()
  // 获取当前用户ID
  const currentUserId = userStore.userInfo?.id ? String(userStore.userInfo.id) : ''

  // 保存切换前的admin_id值用于比较
  const oldAdminId = queryForm.admin_id

  // 标记应该忽略高级搜索中的admin_id
  ignoreAdvancedSearchAdminId.value = true

  // 根据tab更新查询参数
  if (activeListTab.value === 'my') {
    // 我的客户 - 设置当前用户ID
    queryForm.admin_id = currentUserId
  } else {
    // 全部客户 - 将admin_id设置为null，确保在请求时被完全移除
    queryForm.admin_id = null as any // 使用null而不是空字符串，确保参数被删除
  }

  // 重置高级搜索表单中的admin_id，避免干扰tab切换逻辑
  advancedForm.admin_id = null

  // 检查是否需要更新查询参数
  // 修复逻辑：只要tab切换了，就应该重新加载数据
  // 不管admin_id是否发生变化，tab切换都应该触发数据加载
  loadCustomerList()
}

// 处理Tab点击事件（Element Plus Tabs组件的回调）
const handleTabClick = (tab: any) => {
  // Element Plus Tabs组件点击时会调用此方法
  console.log('Tab点击事件，当前tab:', tab.props.name)

  // 确保activeListTab的值与当前点击的标签一致
  activeListTab.value = tab.props.name
  console.log('已更新activeListTab值为:', activeListTab.value)

  // 处理标签切换逻辑
  handleTabChange()
}

// 添加一个初始化Tab状态的函数
const initTabState = () => {
  // 使用用户存储获取当前用户信息，而不是直接从localStorage获取
  const userStore = useUserStore()
  // 获取当前用户ID
  const currentUserId = userStore.userInfo?.id ? String(userStore.userInfo.id) : ''

  // 标记应该忽略高级搜索中的admin_id
  ignoreAdvancedSearchAdminId.value = true

  // 根据当前tab设置初始查询参数
  if (activeListTab.value === 'my') {
    // 我的客户 - 设置当前用户ID
    queryForm.admin_id = currentUserId
  } else {
    // 全部客户 - 将admin_id设置为null，确保在请求时被完全移除
    queryForm.admin_id = null as any
  }

  // 确保高级搜索表单中的admin_id为null
  advancedForm.admin_id = null

  console.log('初始化Tab状态，当前tab:', activeListTab.value, '设置admin_id为:', queryForm.admin_id)
}

// 防重复请求状态管理
const customerListRequestCache = ref<
  Map<
    string,
    {
      promise: Promise<any>
      timestamp: number
    }
  >
>(new Map())

// 查询客户列表
const loadCustomerList = async () => {
  // 生成请求键，基于当前查询参数
  const paramsKey = JSON.stringify(queryForm)
  const currentTime = Date.now()

  // 检查是否已有相同的请求正在进行中
  const existingRequest = customerListRequestCache.value.get(paramsKey)
  if (existingRequest) {
    const timeDiff = currentTime - existingRequest.timestamp
    // 如果请求在5分钟内，直接返回缓存的Promise
    if (timeDiff < 5 * 60 * 1000) {
      console.log('客户列表请求已在进行中，返回缓存的Promise')
      try {
        await existingRequest.promise
        return
      } catch (error) {
        // 如果缓存的请求失败，继续执行新的请求
        console.log('缓存的请求失败，执行新的请求')
      }
    } else {
      // 缓存过期，移除
      customerListRequestCache.value.delete(paramsKey)
    }
  }

  loading.value = true

  // 创建新的请求Promise
  const requestPromise = (async () => {
    try {
      // 合并高级搜索条件
      const params: any = { ...queryForm } // 使用any类型避免TypeScript错误

      // 处理客户类型参数
      if (params.type) {
        // 将前端传递的type值映射为后端需要的customer_type值
        const typeMapping: Record<string, number> = {
          '1': 15, // 个人客户
          '2': 16, // 企业客户
        }

        if (typeMapping[params.type]) {
          params.customer_type = typeMapping[params.type]
        }
        delete params.type // 删除原来的type参数，使用customer_type参数
      }

      // 应用已保存的高级搜索条件或当前高级搜索面板中的条件
      if (hasAppliedAdvancedSearch.value || isAdvancedSearch.value) {
        if (advancedForm.createTimeRange && advancedForm.createTimeRange.length === 2) {
          params.start_time = advancedForm.createTimeRange[0]
          params.end_time = advancedForm.createTimeRange[1]
        }
        if (advancedForm.grade_id) params.grade_id = advancedForm.grade_id
        // 处理级联选择器的地区值
        if (advancedForm.region && advancedForm.region.length > 0) {
          // 取最后一级的值作为地区筛选条件，并转换为字符串
          params.region = String(advancedForm.region[advancedForm.region.length - 1])
        }

        // 只有在不忽略高级搜索中的admin_id时才应用它
        if (
          !ignoreAdvancedSearchAdminId.value &&
          advancedForm.admin_id !== null &&
          advancedForm.admin_id !== ''
        ) {
          params.admin_id = advancedForm.admin_id
        }

        if (advancedForm.source_id) params.source_id = advancedForm.source_id

        // 合同金额区间条件
        if (advancedForm.min_amount !== undefined) params.min_amount = advancedForm.min_amount
        if (advancedForm.max_amount !== undefined) params.max_amount = advancedForm.max_amount
      }

      // 确保admin_id参数正确处理
      // 如果admin_id为空字符串或null或undefined，则从参数中移除
      if (params.admin_id === '' || params.admin_id === null || params.admin_id === undefined) {
        delete params.admin_id
      }

      const response: ApiResponse<any> = await customerApi.getCustomerList(params)

      // 统一从ApiResponse中获取并解析数据
      if (response.code === 0) {
        // 修复：正确处理分页数据结构
        if (
          response.data &&
          typeof response.data === 'object' &&
          Array.isArray(response.data.list)
        ) {
          customerList.value = response.data.list
          total.value = response.data.total || 0
        } else if (Array.isArray(response.data)) {
          // 兼容直接返回数组的情况
          customerList.value = response.data
          total.value = response.data.length
        } else {
          customerList.value = []
          total.value = 0
        }
      } else {
        ElMessage.error(response.msg || '获取客户列表失败')
        // 失败时也确保customerList是数组
        customerList.value = []
        total.value = 0
      }
    } catch (error) {
      ElMessage.error('获取客户列表失败')
      // 出错时也确保customerList是数组
      customerList.value = []
      total.value = 0
    } finally {
      loading.value = false
      // 请求完成后移除缓存
      customerListRequestCache.value.delete(paramsKey)
    }
  })()

  // 缓存请求
  customerListRequestCache.value.set(paramsKey, {
    promise: requestPromise,
    timestamp: currentTime,
  })

  // 执行请求
  await requestPromise
}

// 高级搜索相关方法

// 基础搜索表单DOM引用
const basicSearchFormRef = ref<HTMLElement | null>(null)

// 切换高级搜索显示/隐藏
const toggleAdvancedSearch = async () => {
  console.log('toggleAdvancedSearch 被调用，当前状态:', isAdvancedSearch.value)
  isAdvancedSearch.value = !isAdvancedSearch.value
  console.log('切换高级搜索面板状态为:', isAdvancedSearch.value)

  // 当展开高级搜索面板时，检查管家数据
  if (isAdvancedSearch.value) {
    await checkAdminOptions()
  }
}

// 关闭高级搜索面板
const closeAdvancedSearch = () => {
  console.log('关闭高级搜索面板')
  isAdvancedSearch.value = false
}

// 高级搜索筛选
const handleAdvancedSearch = () => {
  // 标记已应用高级搜索条件
  hasAppliedAdvancedSearch.value = true

  // 保存当前标签状态，以便在应用高级搜索后恢复正确的admin_id值
  const currentTab = activeListTab.value
  const userStore = useUserStore()
  const currentUserId = userStore.userInfo?.id ? String(userStore.userInfo.id) : ''

  // 如果不应该忽略高级搜索中的admin_id，并且用户明确选择了管家
  if (
    !ignoreAdvancedSearchAdminId.value &&
    advancedForm.admin_id !== null &&
    advancedForm.admin_id !== ''
  ) {
    queryForm.admin_id = advancedForm.admin_id
  } else {
    // 如果应该忽略高级搜索中的admin_id，或者用户没有选择管家
    // 则根据当前标签设置正确的admin_id
    if (currentTab === 'my') {
      queryForm.admin_id = currentUserId
    } else {
      queryForm.admin_id = null as any
    }
  }

  // 应用高级搜索后，重置忽略标志
  ignoreAdvancedSearchAdminId.value = false
  if (advancedForm.grade_id) queryForm.grade_id = advancedForm.grade_id
  if (advancedForm.region && advancedForm.region.length > 0) {
    queryForm.region = String(advancedForm.region[advancedForm.region.length - 1])
  }
  if (advancedForm.source_id) queryForm.source_id = advancedForm.source_id
  if (advancedForm.min_amount !== undefined) queryForm.min_amount = advancedForm.min_amount
  if (advancedForm.max_amount !== undefined) queryForm.max_amount = advancedForm.max_amount
  if (advancedForm.createTimeRange && advancedForm.createTimeRange.length === 2) {
    queryForm.start_time = advancedForm.createTimeRange[0]
    queryForm.end_time = advancedForm.createTimeRange[1]
  }

  // 执行搜索
  handleSearch()

  // 关闭高级搜索面板
  closeAdvancedSearch()
}

// 重置高级搜索条件
const resetAdvancedSearch = () => {
  advancedForm.admin_id = null
  advancedForm.createTimeRange = []
  advancedForm.grade_id = ''
  advancedForm.region = []
  advancedForm.source_id = ''
  advancedForm.min_amount = undefined
  advancedForm.max_amount = undefined

  // 重置高级搜索应用标志
  hasAppliedAdvancedSearch.value = false

  // 根据当前标签重置queryForm.admin_id
  const userStore = useUserStore()
  const currentUserId = userStore.userInfo?.id ? String(userStore.userInfo.id) : ''

  if (activeListTab.value === 'my') {
    queryForm.admin_id = currentUserId
  } else {
    queryForm.admin_id = null as any
  }
}

// 添加客户
const handleAdd = () => {
  drawerVisible.value = true
}

// 表格选择项变化
const handleSelectionChange = (selection: any[]) => {
  selectedCustomers.value = selection
}

// 批量删除
const handleBatchDelete = () => {
  if (selectedCustomers.value.length === 0) {
    ElMessage.warning('请先选择要删除的客户')
    return
  }

  ElMessageBox.confirm(`确定要删除选中的 ${selectedCustomers.value.length} 个客户吗？`, '提示', {
    confirmButtonText: '确定',
    cancelButtonText: '取消',
    type: 'warning',
  })
    .then(async () => {
      try {
        // 这里调用批量删除API
        ElMessage.success('批量删除成功')
        loadCustomerList()
      } catch (error) {
        ElMessage.error('批量删除失败')
      }
    })
    .catch(() => {
      ElMessage.info('已取消删除')
    })
}

// 批量分配
const handleBatchDistribute = () => {
  if (selectedCustomers.value.length === 0) {
    ElMessage.warning('请先选择要分配的客户')
    return
  }

  ElMessageBox.prompt('请输入要分配给的员工ID', '批量分配', {
    confirmButtonText: '确定',
    cancelButtonText: '取消',
    inputPattern: /^\d+$/,
    inputErrorMessage: '请输入有效的员工ID',
  })
    .then(async ({ value }) => {
      try {
        // 这里调用批量分配API
        ElMessage.success('批量分配成功')
        loadCustomerList()
      } catch (error) {
        ElMessage.error('批量分配失败')
      }
    })
    .catch(() => {
      ElMessage.info('已取消分配')
    })
}

// 批量锁定
const handleBatchLock = () => {
  if (selectedCustomers.value.length === 0) {
    ElMessage.warning('请先选择要锁定的客户')
    return
  }

  ElMessageBox.confirm(`确定要锁定选中的 ${selectedCustomers.value.length} 个客户吗？`, '提示', {
    confirmButtonText: '确定',
    cancelButtonText: '取消',
    type: 'warning',
  })
    .then(async () => {
      try {
        // 这里调用批量锁定API
        ElMessage.success('批量锁定成功')
        loadCustomerList()
      } catch (error) {
        ElMessage.error('批量锁定失败')
      }
    })
    .catch(() => {
      ElMessage.info('已取消操作')
    })
}

// 批量解锁
const handleBatchUnlock = () => {
  if (selectedCustomers.value.length === 0) {
    ElMessage.warning('请先选择要解锁的客户')
    return
  }

  ElMessageBox.confirm(`确定要解锁选中的 ${selectedCustomers.value.length} 个客户吗？`, '提示', {
    confirmButtonText: '确定',
    cancelButtonText: '取消',
    type: 'warning',
  })
    .then(async () => {
      try {
        // 这里调用批量解锁API
        ElMessage.success('批量解锁成功')
        loadCustomerList()
      } catch (error) {
        ElMessage.error('批量解锁失败')
      }
    })
    .catch(() => {
      ElMessage.info('已取消操作')
    })
}

// 表格列定义
const customerColumns = ref<TableColumn[]>([
  { prop: 'id', label: 'ID', width: 80, align: 'center' },
  { prop: 'name', label: '客户名称', minWidth: 150, align: 'left' },
  { prop: 'type_label', label: '类型', width: 80, align: 'center' },
  { prop: 'grade_name', label: '等级', width: 80, align: 'center' },
  { prop: 'source_name', label: '客户来源', width: 100, slot: 'source_name', align: 'center' },
  { prop: 'belong_name', label: '管家', width: 100, align: 'center' },
  { prop: 'contract_num', label: '合同数', width: 80, align: 'center' },
  {
    prop: 'contract_amount',
    label: '合同金额',
    width: 120,
    slot: 'contract_amount',
    align: 'right',
  },
  { prop: 'create_time', label: '创建时间', width: 160, align: 'center' },
  { prop: 'follow_time', label: '最近跟进', width: 160, align: 'center' },
])

// 客户状态配置
const customerStatusConfig = {
  1: { type: 'info', text: '潜在客户' },
  2: { type: 'warning', text: '意向客户' },
  3: { type: 'success', text: '成交客户' },
  4: { type: 'danger', text: '流失客户' },
}

// 处理客户分配
const handleDistribute = (row: Customer) => {
  ElMessageBox.prompt('请输入要分配的管家ID', '分配客户', {
    confirmButtonText: '确定',
    cancelButtonText: '取消',
    inputPattern: /\d+/,
    inputErrorMessage: '请输入有效的管家ID',
  })
    .then(async ({ value }) => {
      try {
        const res: any = await customerApi.distributeCustomer({
          id: row.id,
          admin_id: parseInt(value),
        })
        if (res.data.code === 0) {
          ElMessage.success('分配成功')
          loadCustomerList()
        } else {
          ElMessage.error(res.data.msg || '分配失败')
        }
      } catch (error) {
        ElMessage.error('分配失败')
      }
    })
    .catch(() => {
      // 取消操作
    })
}

// 设为当事人
const handleCreateParty = async (row: Customer) => {
  try {
    // 调用后端接口创建当事人
    const request = (await import('@/utils/request')).default
    const res = await request({
      url: '/api/customer/customer/create_party_from_customer',
      method: 'post',
      data: {
        customer_id: row.id,
      },
    })

    if (res.data.code === 0) {
      ElMessage.success('设为当事人成功')
    } else {
      ElMessage.error(res.data.msg || '设为当事人失败')
    }
  } catch (error) {
    ElMessage.error('设为当事人失败')
  }
}

// 处理解锁客户
const handleUnlock = (row: any) => {
  handleLock(row, 0)
}

// 查看客户详情
const handleView = (row: any, event?: Event) => {
  // 防止事件冒泡
  event?.stopPropagation()
  // 确保ID是正确的类型
  currentDetailCustomerId.value = row.id
  // 确保抽屉可见性状态正确设置
  detailDrawerVisible.value = true
}

// 编辑客户
const handleEdit = (row: any, event?: Event) => {
  // 防止事件冒泡
  event?.stopPropagation()
  currentEditCustomerId.value = row.id
  editDrawerVisible.value = true
}

// 加载联系人列表
const loadContactList = async (customerId: number) => {
  try {
    const res = await customerStore.getContactListAction({
      cid: customerId,
      page: 1,
      limit: 100,
    })
    if (res.code === 0) {
      // 确保无论什么情况都返回数组
      let listData: any[] = []
      if (Array.isArray(res.data)) {
        listData = res.data
      } else if (res.data && typeof res.data === 'object') {
        listData = (res.data as any).list || []
      }
      contactList.value = Array.isArray(listData) ? listData : []
    }
  } catch (error) {
    ElMessage.error('获取联系人列表失败')
    contactList.value = [] // 出错时确保是数组
  }
}

// 加载跟进记录列表
const loadTraceList = async (customerId: number) => {
  try {
    const res = await customerStore.getTraceListAction({
      cid: customerId,
      page: 1,
      limit: 100,
    })
    if (res.code === 0) {
      // 确保无论什么情况都返回数组
      let listData: any[] = []
      if (Array.isArray(res.data)) {
        listData = res.data
      } else if (res.data && typeof res.data === 'object') {
        listData = (res.data as any).list || []
      }
      traceList.value = Array.isArray(listData) ? listData : []
    }
  } catch (error) {
    ElMessage.error('获取跟进记录列表失败')
    traceList.value = [] // 出错时确保是数组
  }
}

// 加载销售机会列表
const loadChanceList = async (customerId: number) => {
  try {
    const res = await customerStore.getChanceListAction({
      cid: customerId,
      page: 1,
      limit: 100,
    })
    if (res.code === 0) {
      // 确保无论什么情况都返回数组
      let listData: any[] = []
      if (Array.isArray(res.data)) {
        listData = res.data
      } else if (res.data && typeof res.data === 'object') {
        listData = (res.data as any).list || []
      }
      chanceList.value = Array.isArray(listData) ? listData : []
    }
  } catch (error) {
    ElMessage.error('获取销售机会列表失败')
    chanceList.value = [] // 出错时确保是数组
  }
}

// 加载操作日志列表
const loadLogList = async (customerId: number) => {
  try {
    const res = await customerStore.getLogListAction({
      cid: customerId,
      page: 1,
      limit: 100,
    })
    if (res.code === 0) {
      // 确保无论什么情况都返回数组
      let listData: any[] = []
      if (Array.isArray(res.data)) {
        listData = res.data
      } else if (res.data && typeof res.data === 'object') {
        listData = (res.data as any).list || []
      }
      logList.value = Array.isArray(listData) ? listData : []
    }
  } catch (error) {
    ElMessage.error('获取操作日志列表失败')
    logList.value = [] // 出错时确保是数组
  }
}

// 添加联系人
const handleAddContact = () => {
  ElMessage.info('添加联系人功能开发中...')
}

// 编辑联系人
const handleEditContact = (row: any) => {
  console.log('编辑联系人:', row)
  ElMessage.info('编辑联系人功能开发中...')
}

// 设置默认联系人
const handleSetDefault = (row: any) => {
  ElMessageBox.confirm('确定要将该联系人设为默认联系人吗？', '提示', {
    confirmButtonText: '确定',
    cancelButtonText: '取消',
    type: 'warning',
  })
    .then(async () => {
      try {
        const res: any = await customerStore.setContactAction({
          id: row.id,
        })
        // 修复：正确访问响应数据
        if (res.data.code === 0) {
          ElMessage.success(res.data.msg || '设置成功')
          loadContactList(currentCustomer.value.id)
        } else {
          ElMessage.error(res.data.msg || '设置失败')
        }
      } catch (error) {
        ElMessage.error('设置失败')
      }
    })
    .catch(() => {
      // 用户取消操作
    })
}

// 添加跟进记录
const handleAddTrace = () => {
  ElMessage.info('添加跟进记录功能开发中...')
}

// 查看跟进记录
const handleViewTrace = (_row: any) => {
  ElMessage.info('查看跟进记录功能开发中...')
}

// 添加销售机会
const handleAddChance = () => {
  ElMessage.info('添加销售机会功能开发中...')
}

// 查看销售机会
const handleViewChance = (row: any) => {
  console.log('查看销售机会:', row)
  ElMessage.info('查看销售机会功能开发中...')
}

// 处理下拉菜单命令
const handleCommand = (command: any) => {
  const { action, row } = command
  switch (action) {
    case 'edit':
      ElMessage.info('编辑功能开发中...')
      break
    case 'distribute':
      ElMessage.info('分配功能开发中...')
      break
    case 'lock':
      handleLock(row, 1)
      break
    case 'unlock':
      handleLock(row, 0)
      break
    case 'delete':
      handleDelete(row)
      break
  }
}

// 锁定/解锁客户
const handleLock = (row: any, isLock: number = 1) => {
  const actionText = isLock === 1 ? '锁定' : '解锁'
  ElMessageBox.confirm(`确定要${actionText}该客户吗？`, '提示', {
    confirmButtonText: '确定',
    cancelButtonText: '取消',
    type: 'warning',
  })
    .then(async () => {
      try {
        const res: any = await customerStore.lockCustomerAction({
          id: row.id,
          is_lock: isLock,
        })
        // 修复：正确访问响应数据
        if (res.data.code === 0) {
          ElMessage.success(res.data.msg || `${actionText}成功`)
          loadCustomerList()
        } else {
          ElMessage.error(res.data.msg || `${actionText}失败`)
        }
      } catch (error) {
        ElMessage.error(`${actionText}失败`)
      }
    })
    .catch(() => {
      // 用户取消操作
    })
}

// 删除客户
const handleDelete = (row: any) => {
  ElMessageBox.confirm('确定要删除该客户吗？删除后将无法恢复！', '提示', {
    confirmButtonText: '确定',
    cancelButtonText: '取消',
    type: 'warning',
  })
    .then(async () => {
      try {
        const res: any = await customerStore.deleteCustomerAction({
          id: row.id,
        })
        // 修复：正确访问响应数据
        if (res.data.code === 0) {
          ElMessage.success(res.data.msg || '删除成功')
          loadCustomerList()
        } else {
          ElMessage.error(res.data.msg || '删除失败')
        }
      } catch (error) {
        ElMessage.error('删除失败')
      }
    })
    .catch(() => {
      // 用户取消操作
    })
}

// 分页相关
const handleSizeChange = (val: number) => {
  queryForm.limit = val
  queryForm.page = 1
  loadCustomerList()
}

const handleCurrentChange = (val: number) => {
  queryForm.page = val
  loadCustomerList()
}

// 获取地区名称
const getRegionName = (row: any) => {
  let regionName = ''
  // 如果数据中有直接的地区名称字段，优先使用
  if (row.customer_region) {
    return row.customer_region
  }

  // 通过省、市、区字段组合
  const provinceId = row.provinceid
  const cityId = row.cityid
  const distId = row.distid

  // 这里可以根据实际情况进行地区数据的查询和格式化
  // 目前简单处理为"省-市-区"的格式
  if (provinceId && areaMapping[provinceId]) {
    regionName += areaMapping[provinceId]

    if (cityId && areaMapping[cityId]) {
      regionName += '-' + areaMapping[cityId]

      if (distId && areaMapping[distId]) {
        regionName += '-' + areaMapping[distId]
      }
    }
  }

  return regionName || '未知地区'
}

// 地区映射数据（实际项目中应从后端获取）
const areaMapping: Record<number, string> = {
  30996: '浙江省',
  31784: '杭州市',
  31824: '西湖区',
  31837: '余杭区',
  31961: '滨江区',
  31993: '绍兴市',
  32074: '诸暨市',
}

/**
 * 加载选项数据 - 统一处理客户管理相关字典数据
 * @description 从服务器获取或从本地缓存读取各类字典数据，用于客户列表页面的下拉选择控件
 * @note 所有客户相关的字典数据均来自oa_basic_customer表，通过不同的API接口和type参数进行区分
 * @returns {Promise<void>} 无返回值
 */
const loadOptions = async () => {
  console.log('开始加载选项数据...')
  try {
    // 定义缓存键名
    const CACHE_KEYS = {
      ADMIN_LIST: 'customer_admin_list_cache',
      GRADE_OPTIONS: 'customer_grade_options_cache',
      SOURCE_OPTIONS: 'customer_source_options_cache',
      STATUS_OPTIONS: 'customer_status_options_cache',
    }

    // 定义缓存过期时间（24小时）
    const CACHE_EXPIRY = 24 * 60 * 60 * 1000
    // 管家列表缓存时间较短（1小时）
    const ADMIN_CACHE_EXPIRY = 60 * 60 * 1000

    // 获取缓存数据的辅助函数
    const getCachedData = (key: string, expiry: number = CACHE_EXPIRY) => {
      try {
        const cached = localStorage.getItem(key)
        if (cached) {
          const parsed = JSON.parse(cached)
          const now = Date.now()
          if (parsed.timestamp && now - parsed.timestamp < expiry) {
            console.log(
              `从缓存获取${key}数据，有效时间剩余: ${Math.floor((expiry - (now - parsed.timestamp)) / (60 * 1000))}分钟`
            )
            return parsed.data
          } else {
            console.log(`${key}缓存已过期，将重新获取数据`)
          }
        }
      } catch (error) {
        console.error(`获取缓存数据${key}失败:`, error)
      }
      return null
    }

    // 设置缓存数据的辅助函数
    const setCachedData = (key: string, data: any) => {
      try {
        const cacheData = {
          data,
          timestamp: Date.now(),
        }
        localStorage.setItem(key, JSON.stringify(cacheData))
        console.log(`数据已保存到缓存: ${key}`)
      } catch (error) {
        console.error(`保存缓存数据${key}失败:`, error)
      }
    }

    // 加载管家列表选项 - 调用统一的加载函数
    console.log('加载管家列表选项...')
    await loadAdminData()

    // 加载客户基础数据（一次性获取所有基础数据，避免多次API调用）
    let basicData = null
    try {
      console.log('加载客户基础数据...')
      const basicRes: any = await customerApi.getOptions()
      console.log('客户基础数据响应:', basicRes)
      if (basicRes.code === 0 && basicRes.data) {
        basicData = basicRes.data
      }
    } catch (error) {
      console.error('加载客户基础数据失败:', error)
    }

    // 加载客户等级选项（从oa_basic_customer表获取，type=4）
    try {
      console.log('加载客户等级选项...')
      // 先尝试从缓存获取
      const cachedGrades = getCachedData(CACHE_KEYS.GRADE_OPTIONS)
      if (cachedGrades) {
        gradeOptions.value = cachedGrades
      } else if (basicData && basicData.grade_options && Array.isArray(basicData.grade_options)) {
        // 从基础数据中提取等级选项
        gradeOptions.value = basicData.grade_options.map((item: any) => ({
          id: item.id,
          name: item.title,
        }))
        // 保存到缓存
        setCachedData(CACHE_KEYS.GRADE_OPTIONS, gradeOptions.value)
      }
    } catch (error) {
      console.error('加载客户等级选项失败:', error)
    }

    // 确保使用静态数据作为后备
    if (gradeOptions.value.length === 0) {
      console.log('使用客户等级静态数据作为备用')
      gradeOptions.value = [
        { id: '1', name: '普通客户' },
        { id: '2', name: '重要客户' },
        { id: '3', name: 'VIP客户' },
      ]
    }

    // 加载客户状态选项（从oa_basic_customer表获取，type=1）
    try {
      console.log('加载客户状态选项...')
      // 先尝试从缓存获取
      const cachedStatuses = getCachedData(CACHE_KEYS.STATUS_OPTIONS)
      if (cachedStatuses) {
        customerStatusOptions.value = cachedStatuses
      } else {
        // 缓存不存在或已过期，从服务器获取
        // 使用customerApi.getStatusOptions()获取状态选项
        const statusRes: any = await customerApi.getStatusOptions()
        console.log('客户状态选项响应:', statusRes)
        if (statusRes.code === 0 && statusRes.data) {
          // 后端返回的数据格式为 { customer_status: [{value, label}, ...] }
          // 需要转换为前端期望的格式 { id, name }
          if (statusRes.data.customer_status && Array.isArray(statusRes.data.customer_status)) {
            customerStatusOptions.value = statusRes.data.customer_status.map((item: any) => ({
              id: item.value,
              name: item.label,
            }))
          } else if (Array.isArray(statusRes.data)) {
            customerStatusOptions.value = statusRes.data.map((item: any) => ({
              id: item.value,
              name: item.label,
            }))
          }
          // 保存到缓存
          setCachedData(CACHE_KEYS.STATUS_OPTIONS, customerStatusOptions.value)
        }
      }
    } catch (error) {
      console.error('加载客户状态选项失败:', error)
    }

    // 确保使用静态数据作为后备
    if (customerStatusOptions.value.length === 0) {
      console.log('使用客户状态静态数据作为备用')
      // 使用与API默认值一致的会员状态选项
      customerStatusOptions.value = [
        { id: '2', name: '会员' },
        { id: '3', name: '非会员' },
        { id: '20', name: '过期会员' },
      ]
    }

    // 加载来源选项（从oa_basic_customer表获取，type=3）
    try {
      console.log('加载来源选项...')
      // 先尝试从缓存获取
      const cachedSources = getCachedData(CACHE_KEYS.SOURCE_OPTIONS)
      if (cachedSources) {
        sourceOptions.value = cachedSources
      } else {
        // 缓存不存在或已过期，从服务器获取
        // 使用customerApi.getSourceOptions()获取来源选项（与新增客户表单保持一致）
        const sourceRes: any = await customerApi.getSourceOptions()
        console.log('来源选项响应:', sourceRes)
        if (sourceRes.code === 0 && sourceRes.data) {
          if (Array.isArray(sourceRes.data)) {
            sourceOptions.value = sourceRes.data.map((item: any) => ({
              id: item.id,
              name: item.title || item.name,
            }))
          } else if (sourceRes.data.list && Array.isArray(sourceRes.data.list)) {
            sourceOptions.value = sourceRes.data.list.map((item: any) => ({
              id: item.id,
              name: item.title || item.name,
            }))
          }
          // 保存到缓存
          setCachedData(CACHE_KEYS.SOURCE_OPTIONS, sourceOptions.value)
        }
      }
    } catch (error) {
      console.error('加载来源选项失败:', error)
    }

    // 确保使用静态数据作为后备
    if (sourceOptions.value.length === 0) {
      console.log('使用来源静态数据作为备用')
      sourceOptions.value = [
        { id: '1', name: '网站' },
        { id: '2', name: '电话' },
        { id: '3', name: '展会' },
        { id: '4', name: '转介绍' },
        { id: '5', name: '广告' },
        { id: '6', name: '社交媒体' },
        { id: '7', name: '搜索引擎' },
        { id: '8', name: '其他渠道' },
      ]
    }

    // 使用优化版地区数据Hook
    const { provinces: regionProvinces, loadProvinces } = useRegionOptimized()

    // 加载地区选项 - 使用优化版API
    try {
      console.log('开始加载地区选项...')
      await loadProvinces()
      console.log('地区数据加载完成，省份数量:', regionProvinces.value?.length || 0)

      // 定义地区数据接口
      interface RegionNode {
        id: number
        name: string
        initial?: string
        pinyin?: string
        has_children?: boolean
        parent_id?: number
        children?: RegionNode[]
      }

      // 转换为级联选择器格式 - 使用已加载的地区数据
      if (Array.isArray(regionProvinces.value)) {
        cascaderRegionOptions.value = regionProvinces.value.map((province: RegionNode) => ({
          value: province.id,
          label: province.name,
          children:
            province.children?.map((city: RegionNode) => ({
              value: city.id,
              label: city.name,
              children:
                city.children?.map((district: RegionNode) => ({
                  value: district.id,
                  label: district.name,
                })) || [],
            })) || [],
        }))
      } else {
        console.warn('地区数据格式不正确，无法转换为级联选择器格式')
        cascaderRegionOptions.value = []
      }
    } catch (error) {
      console.error('加载地区选项失败:', error)
      // 不显示错误消息，避免用户体验问题
      cascaderRegionOptions.value = []
    }

    console.log('选项数据加载完成')
    console.log('管家选项数量:', adminOptions.value.length)
    console.log('等级选项数量:', gradeOptions.value.length)
    console.log('状态选项数量:', customerStatusOptions.value.length)
    console.log('来源选项数量:', sourceOptions.value.length)
    console.log('地区选项数量:', cascaderRegionOptions.value.length)
  } catch (error) {
    console.error('加载选项数据失败:', error)
    // 强制使用所有静态数据作为最后的备用方案
    console.log('强制使用所有静态数据作为备用')
    adminOptions.value = [
      { id: 1, name: '管理员' },
      { id: 2, name: '销售经理' },
      { id: 3, name: '客户经理' },
      { id: 4, name: '项目经理' },
      { id: 5, name: '财务经理' },
    ]
    gradeOptions.value = [
      { id: '1', name: '普通客户' },
      { id: '2', name: '重要客户' },
      { id: '3', name: 'VIP客户' },
    ]
    customerStatusOptions.value = [
      { id: '2', name: '会员' },
      { id: '3', name: '非会员' },
      { id: '20', name: '过期会员' },
    ]
    sourceOptions.value = [
      { id: '1', name: '网站' },
      { id: '2', name: '电话' },
      { id: '3', name: '展会' },
      { id: '4', name: '转介绍' },
      { id: '5', name: '广告' },
      { id: '6', name: '社交媒体' },
      { id: '7', name: '搜索引擎' },
      { id: '8', name: '其他渠道' },
    ]
    cascaderRegionOptions.value = [
      {
        value: 1,
        label: '北京市',
        children: [
          {
            value: 2,
            label: '北京市',
            children: [
              { value: 3, label: '东城区' },
              { value: 4, label: '西城区' },
            ],
          },
        ],
      },
      {
        value: 5,
        label: '上海市',
        children: [
          {
            value: 6,
            label: '上海市',
            children: [
              { value: 7, label: '黄浦区' },
              { value: 8, label: '徐汇区' },
            ],
          },
        ],
      },
    ]
  }
}

// 直接从服务器刷新管家列表数据
const refreshAdminList = async () => {
  console.log('开始直接从服务器刷新管家列表...')
  try {
    // 直接调用API
    const adminRes: any = await customerApi.getAdminList()
    console.log('管家列表API响应:', adminRes)

    if (adminRes.code === 0) {
      // 处理数据 - 根据新接口返回数据结构提取管家列表
      let adminData = []

      // 新接口返回的数据结构是直接的数组
      if (Array.isArray(adminRes.data)) {
        adminData = adminRes.data
      }

      // 更新管家列表
      adminOptions.value = adminData.map((item: any) => ({
        id: item.id,
        name: item.name || item.username || item.nickname || `管家${item.id}`,
      }))

      // 更新缓存
      try {
        const cacheData = {
          data: adminOptions.value,
          timestamp: Date.now(),
        }
        localStorage.setItem('customer_admin_list_cache', JSON.stringify(cacheData))
        console.log('管家列表数据已更新缓存')
      } catch (e) {
        console.error('更新管家列表缓存失败:', e)
      }

      console.log('管家列表刷新成功，数量:', adminOptions.value.length)

      ElMessage.success('管家列表已刷新')
      return true
    } else {
      console.error('获取管家列表失败:', adminRes.msg || '未知错误')
      return false
    }
  } catch (error) {
    console.error('刷新管家列表失败:', error)
    return false
  }
}

// 在展开高级搜索时检查管家数据 - 优先使用缓存
const checkAdminOptions = async () => {
  console.log('检查管家数据，当前数据量:', adminOptions.value.length)
  // 如果管家列表已有数据，则不再重新获取
  if (adminOptions.value.length > 0) {
    console.log('展开高级搜索，管家数据已存在，数量:', adminOptions.value.length)
    return
  }

  console.log('展开高级搜索，检查管家数据缓存')

  // 调用统一的加载函数，确保数据被加载
  await loadAdminData()
}

// 强制刷新配置数据缓存
const refreshConfigCache = async () => {
  console.log('强制刷新配置数据缓存...')

  // 清除所有配置数据缓存
  const CACHE_KEYS = [
    'customer_admin_list_cache',
    'customer_grade_options_cache',
    'customer_source_options_cache',
  ]

  CACHE_KEYS.forEach(key => {
    localStorage.removeItem(key)
    console.log(`已清除缓存: ${key}`)
  })

  // 重新加载配置数据（包括管家数据）
  await loadOptions()

  ElMessage.success('配置数据已更新')
}

// 页面初始化时自动清除一次缓存，确保使用最新数据
// 仅在开发环境或首次加载时执行，避免频繁清除缓存影响性能
const shouldClearCacheOnLoad = () => {
  // 开发环境或7天内未清除缓存
  const lastClearTime = localStorage.getItem('last_config_cache_clear')
  const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000
  return !lastClearTime || parseInt(lastClearTime) < sevenDaysAgo
}

// 初始化时执行一次缓存清理检查
if (shouldClearCacheOnLoad()) {
  console.log('检测到需要清理缓存，将在页面加载后执行')
  localStorage.setItem('last_config_cache_clear', Date.now().toString())
  // 使用setTimeout确保在组件挂载后执行
  setTimeout(() => {
    refreshConfigCache()
  }, 1000)
}

// 保存用户Token到localStorage
const saveUserToken = (token: string) => {
  if (token && token.startsWith('Bearer ')) {
    // 从Bearer格式中提取实际的令牌
    const actualToken = token.substring(7)
    localStorage.setItem('token', actualToken)
    console.log('已保存新的Token到localStorage')
    // 刷新配置缓存，重新加载数据
    refreshConfigCache()
  }
}

// 处理抽屉确认按钮点击 - 新增客户
const handleConfirmAdd = () => {
  console.log('点击新增客户抽屉的确认按钮')
  if (customerAddRef.value) {
    // 调用子组件的提交方法
    customerAddRef.value.handleSubmit()
  } else {
    console.error('找不到客户添加组件的引用')
  }
}

// 注意：在组件挂载时，管家数据会在loadOptions函数中自动加载
// 这里不再单独调用loadAdminData()，避免重复加载

// 导出所有需要在模板中使用的变量和方法
export {
  // 响应式数据
  activeListTab,
  queryForm,
  advancedForm,
  isAdvancedSearch,
  adminOptions,
  gradeOptions,
  customerStatusOptions,
  sourceOptions,
  cascaderRegionOptions,
  cascaderProps,
  selectedCustomers,
  customerList,
  total,
  loading,
  detailDrawerVisible,
  currentDetailCustomerId,
  detailDialogVisible,
  currentCustomer,
  activeTab,
  contactList,
  traceList,
  chanceList,
  logList,
  drawerVisible,
  editDrawerVisible,
  currentEditCustomerId,
  submitting,
  regionData,
  customerColumns,
  customerStatusConfig,
  customerAddRef,

  // 方法
  formatAmount,
  handleSearch,
  handleReset,
  closeDrawer,
  closeDetailDrawer,
  closeEditDrawer,
  handleAddSubmit,
  handleEditSubmit,
  submitForm,
  submitEditForm,
  handleTabChange,
  handleTabClick,
  initTabState,
  loadCustomerList,
  toggleAdvancedSearch,
  closeAdvancedSearch,
  handleAdvancedSearch,
  resetAdvancedSearch,
  handleAdd,
  handleSelectionChange,
  handleBatchDelete,
  handleBatchDistribute,
  handleBatchLock,
  handleBatchUnlock,
  handleView,
  handleEdit,
  handleDelete,
  handleLock,
  handleUnlock,
  handleDistribute,
  handleCreateParty,
  loadContactList,
  loadTraceList,
  loadChanceList,
  loadLogList,
  handleAddContact,
  handleEditContact,
  handleSetDefault,
  handleAddTrace,
  handleViewTrace,
  handleAddChance,
  handleViewChance,
  handleCommand,
  handleSizeChange,
  handleCurrentChange,
  getRegionName,
  loadOptions,
  refreshAdminList,
  refreshConfigCache,
  saveUserToken,
  checkAdminOptions,
  handleConfirmAdd,
}
